In a conventional microprocessor, the state of the microprocessor must be saved when changing context while handling a trap. A trap may occur due to an interrupt received by the microprocessor from an external device or an exception detected by the microprocessor. This change of context involves saving the operands stored by the working registers of the microprocessor to the main memory of the microprocessor. However, the context switching overhead required to accomplish this operation is large since it is time consuming and a large portion of the main memory is used.
Several solutions have been proposed to reduce the large context switching overhead in a microprocessor. Each of these solutions recognizes that, at the time of a context switch, some of the working registers of the microprocessor contain active operands (i.e., operands still needed by the instruction stream) while others contain inactive operands (i.e., operands no longer needed by the instruction stream). These solutions require tracking of the active operands so that they are saved to the main memory during the next context switch.
One solution is to provide the microprocessor with register windows for the working registers. However, this is a complicated and hardware intensive way to postpone saving of the active operands to main memory until absolutely necessary. Thus, the context switching overhead for this solution is extremely large.
A more efficient solution is to include a dirty bit register for each working register. When a particular working register is written to with a new operand, then the dirty bit stored by the corresponding dirty bit register is set to indicate that the working register is dirty (i.e., has been written to) and stores an active operand that needs to be saved to memory at the next context switch. When the next context switch does occur, the operand is saved to the main memory and the dirty bit is cleared (i.e., re-set).
The problem with this solution is that the operand may have become inactive well before the next context switch even though the dirty bit still indicates that the operand is active. The microprocessor will then needlessly store this inactive operand to the main memory at the next context switch. This may also be the case for many other operands stored by the working registers. Thus, a bottleneck is created in saving these operands at the next context switch. This makes the context switching overhead for this solution unnecessarily large.